const Common = require('./common');
//引入公共方法 
const async = require('async');
//引入async 
const dateFormat = require('dateformat');
//引入dateformat模块 
const CateModel = require('../models/cate');
//引入cate表的model实例 
// 引入article表的model实例 
const ArticleModel = require('../models/article');
const InfoModel = require('../models/info');
//引入info表的model实例 
const Constant = require('../constant/constant');
//引入常量constant 
// 配置导出对象
let exportObj = {
    index,
    cate,
    article,
    about,
};
module.exports = exportObj;
// 导出对象，供其他模块调用 

// 首页渲染方法
function index(req, res) { // 首页方法 
    let returnObj = {}; // 设定一个对象，用于保存方法返回的数据 
    let rows = 2; // SQL语句中需要的limit，即查询多少条 
    let page = req.query.page || 1; // 当前页码 
    // 定义一个async任务 
    let tasks = {
        // 查询文章方法 
        queryArticle: cb => {
            // 根据前端提交参数计算SQL语句中需要的offset，即从多少条开始查询 
            let offset = rows * (page - 1);
            // 通过offset和limit使用admin的model到数据库中查询 
            // 并按照创建时间排序 
            ArticleModel
                .findAndCountAll({
                    offset: offset,
                    limit: rows,
                    order: [
                        ['created_at', 'DESC']
                    ],
                    // 关联cate表进行联表查询 
                    include: [{
                        model: CateModel
                    }]
                })
                .then(function(result) {
                    // 查询结果处理 
                    let list = []; // 定义一个空数组list，用来存放最终的结果 
                    // 遍历SQL查询出来的结果，处理后装入list 
                    result.rows.forEach((v, i) => {
                        // 将结果的每一项给数组list每一项赋值 
                        let obj = {
                            id: v.id,
                            title: v.title,
                            desc: v.desc,
                            cate: v.cate,
                            cateName: v.Cate.name,
                            createdAt: dateFormat(v.createdAt, 'yyyy-mm-dd HH:MM:ss')
                        };
                        list.push(obj);
                    });
                    // 推给公共方法的参数 
                    returnObj.template = 'index';
                    // 要渲染的模板 
                    returnObj.path = 'index';
                    // 请求的路径 
                    returnObj.data = {
                        // 页面渲染数据 
                        list: list,
                        // 列表数据 
                        page: Number(page),
                        // 当前页码 
                        pageCount: Math.ceil(result.count / rows)
                            // 总页数 
                    };
                    cb(null);
                    // 继续后续操作 
                })
                .catch(function(err) {
                    // 错误处理 
                    console.log(err); // 打印错误日志 
                    cb(Constant.DEFAULT_ERROR); // 传递错误信息到async的最终方法中 
                });
        }
    };
    Common.autoFn(tasks, res, returnObj); // 执行公共方法中的autoFn方法 
}

// 分类页渲染方法
function cate(req, res) {
    let returnObj = {}; // 设定一个对象，用于保存方法返回的数据 
    let rows = 2; // SQL语句中需要的limit，即查询多少条 
    let page = req.query.page || 1; // 当前页码 
    let curCate = req.params.cateId; // 当前分类id 
    // 定义一个async任务 
    let tasks = {
        // 查询文章方法 
        queryArticle: cb => {
            // 根据前端提交参数计算SQL语句中需要的offset，即从多少条开始查询 
            let offset = rows * (page - 1);
            // 通过offset和limit使用admin的model去数据库中查询 
            // 并按照创建时间排序 
            ArticleModel
                .findAndCountAll({
                    // 按分类查询 
                    where: {
                        cate: curCate
                    },
                    offset: offset,
                    limit: rows,
                    order: [
                        ['created_at', 'DESC']
                    ],
                    // 关联cate表进行联表查询 
                    include: [{
                        model: CateModel
                    }]
                })
                .then(function(result) {
                    // 查询结果处理 
                    let list = []; // 定义一个空数组list，用来存放最终结果 
                    let curCateName = ''; // 设定变量，保存当前分类名称 
                    // 遍历SQL查询出来的结果，处理后装入list 
                    result.rows.forEach((v, i) => {
                        // 查询出当前分类对应的分类名称 
                        if (v.cate == curCate) {
                            curCateName = v.Cate.name
                        }
                        // 将结果的每一项给数组list的每一项赋值 
                        let obj = {
                            id: v.id,
                            title: v.title,
                            desc: v.desc,
                            cate: v.cate,
                            cateName: v.Cate.name,
                            createdAt: dateFormat(v.createdAt, 'yyyy-mm-dd HH:MM:ss')
                        };
                        list.push(obj);
                    });
                    // 推给公共方法的参数 
                    returnObj.template = 'cate';
                    // 要渲染的模板 
                    returnObj.path = 'cate';
                    // 请求的路径 
                    returnObj.curCate = curCate;
                    // 当前分类 
                    returnObj.title = curCateName;
                    // 当前分类名称 
                    returnObj.data = {
                        // 页面渲染数据 
                        list: list,
                        // 列表数据 
                        page: Number(page),
                        // 当前页码 
                        pageCount: Math.ceil(result.count / rows)
                            // 总页数 
                    };
                    cb(null);
                    // 继续后续操作 
                })
                .catch(function(err) {
                    // 错误处理 
                    console.log(err); // 打印错误日志 
                    cb(Constant.DEFAULT_ERROR); // 传递错误信息到async的最终方法中 
                });
        }
    };
    Common.autoFn(tasks, res, returnObj) // 执行公共方法中的autoFn方法 
}


// 文章页渲染方法 
function article(req, res) {
    let returnObj = {}; // 设定一个对象，用于保存方法返回的数据 
    // 定义一个async任务 
    let tasks = {
        // 通过文章id，从数据库中查询 
        queryArticle: cb => {
            ArticleModel
                .findByPk(
                    req.params.articleId, {
                        include: [{
                            model: CateModel // 关联cate表进行查询 
                        }]
                    })
                .then(function(result) {
                    // 查询结果处理 
                    // 将结果中的属性值给保存对象赋值 
                    let obj = {
                        id: result.id,
                        title: result.title,
                        content: result.content,
                        cate: result.cate,
                        cateName: result.Cate.name,
                        createdAt: dateFormat(result.createdAt, 'yyyy-mm-dd HH:MM:ss')
                    };
                    // 推给公共方法的参数 
                    returnObj.template = 'article'; // 要渲染的模板 
                    returnObj.curCate = obj.cate; // 当前文章所属分类 
                    returnObj.title = obj.cateName; // 当前文章所属分类的名称 
                    returnObj.path = 'article'; // 请求的路径 
                    returnObj.title = obj.title; // 页面标题title 
                    returnObj.data = obj;
                    // 查询结果赋值 
                    cb(null);
                    // 继续后续操作 
                })
                .catch(function(err) {
                    // 错误处理 
                    console.log(err);
                    // 打印错误日志 
                    cb(Constant.DEFAULT_ERROR); // 传递错误信息到async的最终方法中 
                });
        }
    };
    Common.autoFn(tasks, res, returnObj) // 执行公共方法中的autoFn方法 
}


// “关于我们页”渲染方法 
function about(req, res) {
    let returnObj = {}; // 设定一个对象，用于保存方法返回的数据 
    // 定义一个async任务 
    let tasks = {
        // 查询方法 
        query: cb => {
            // 去数据库中查询固定id为1的数据 
            InfoModel
                .findByPk(1)
                .then(function(result) {
                    // 查询结果处理 
                    // 将结果中的属性值给保存对象赋值 
                    let obj = {
                        id: result.id,
                        title: result.title,
                        subtitle: result.subtitle,
                        about: result.about,
                        createdAt: dateFormat(result.createdAt, 'yyyy-mm-dd HH:MM:ss')
                    };
                    // 推给公共方法的参数 
                    returnObj.template = 'about'; // 要渲染的模板 
                    returnObj.path = 'about'; // 请求的路径 查询结
                    returnObj.data = obj; // 查询结果赋值 
                    cb(null); // 继续后续操作 
                })
                .catch(function(err) {
                    // 错误处理 
                    console.log(err); // 打印错误日志 
                    cb(Constant.DEFAULT_ERROR); // 传递错误信息到async的最终方法中 
                });
        }
    };
    Common.autoFn(tasks, res, returnObj) // 执行公共方法中的autoFn方法 
}